Python intro
Contents
Python intro#
gdsfactory is written in python and requires some basic knowledge of python.
If you are new to python you can find many resources online
This notebook is for you to experiment with some common python patterns in gdsfactory
Classes#
Gdsfactory has already some pre-defined classes for you. The only class you may need to define is a Layermap. Which can be easily defined as a dataclass
All the other classes (Component, ComponentReference, Port …) are already available in gf.types
Classes are good for keeping state, which means that they store some information inside them (polygons, ports, references …)
[1]:
import gdsfactory as gf
gf.CONF.plotter = "holoviews"
c = gf.Component(name="my_fist_class")
c.add_polygon([(-8, 6, 7, 9), (-6, 8, 17, 5)], layer=(1, 0))
c
2022-09-10 15:49:25.152 | INFO | gdsfactory.config:<module>:53 - Load '/home/runner/work/gdsfactory/gdsfactory/gdsfactory' 5.28.0
[1]:
[2]:
c.ploth()
[2]:
Functions#
Functions have clear inputs and outputs, they usually accept some parameters (strings, floats, ints …) and return other parameters
[3]:
def double(x):
return 2 * x
x = 1.5
y = double(x)
print(y)
3.0
It’s also nice to add type annotations to your functions to clearly define what are the input/output types (string, int, float …)
[4]:
def double(x: float) -> float:
return 2 * x
Factories#
A factory is a function that returns an object. In gdsfactory many functions return a Component object
[5]:
def bend(radius: float = 5) -> gf.types.Component:
return gf.components.bend_euler(radius=radius)
component = bend(radius=10)
print(component)
component.plot()
bend_euler_radius10: uid 1, ports ['o1', 'o2'], references [], 4 polygons
[5]:
Decorators#
gdsfactory has many functions, and we want to do some common operations for the ones that return a Component:
give a unique name (dependent on the input parameters) to a Component
validate input arguments based on type annotations
cache the Component that the function returns for speed and reuse cells.
For that you will see a @cell decorator on many component functions.
The validation functionality comes from the pydantic package and is available to you automatically when using the @cell decorator
[6]:
from pydantic import validate_arguments
@validate_arguments
def double(x: float) -> float:
return 2 * x
x = 1.5
y = double(x)
print(y)
3.0
The validator decorator is equivalent to running
[7]:
def double(x: float) -> float:
return 2 * x
double_with_validator = validate_arguments(double)
x = 1.5
y = double_with_validator(x)
print(y)
3.0
The cell decorator also leverages that validate arguments. So you should add type annotations to your component factories.
Lets try to create an error x and you will get a clear message the the function double does not work with strings
y = double('not_valid_number')
will raise a ValidationError
ValidationError: 0 validation error for Double
x
value is not a valid float (type=type_error.float)
It will also cast the input type based on the type annotation. So if you pass an int it will convert it to float
[8]:
x = 1
y = double_with_validator(x)
print(y, type(x), type(y))
2.0 <class 'int'> <class 'float'>
List comprehensions#
You will also see some list comprehensions, which are common in python.
For example, you can write many loops in one line
[9]:
y = []
for x in range(3):
y.append(double(x))
print(y)
[0, 2, 4]
[10]:
y = [double(x) for x in range(3)] # much shorter and easier to read
print(y)
[0, 2, 4]
Functional programming#
Functional programming follows linux philosophy:
Write functions that do one thing and do it well.
Write functions to work together.
Write functions with clear inputs and outputs
partial#
Partial is an easy way to modify the default arguments of a function. This is useful in gdsfactory because we define Pcells using functions.
gdsfactory.partial comes from the module functools.partial, which is available in the standard python library.
The following two functions are equivalent in functionality.
Notice how the second one is shorter, more readable and easier to maintain thanks to gf.partial
[11]:
def ring_sc(gap=0.3, **kwargs):
return gf.components.ring_single(gap=gap, **kwargs)
ring_sc = gf.partial(gf.components.ring_single, gap=0.3)
As you customize more parameters, it’s more obvious that the second one is easier to maintain
[12]:
def ring_sc(gap=0.3, radius=10, **kwargs):
return gf.components.ring_single(gap=gap, radius=radius, **kwargs)
ring_sc = gf.partial(gf.components.ring_single, gap=0.3, radius=10)
compose#
gf.compose combines two functions into one.
[13]:
ring_sc = gf.partial(gf.components.ring_single, radius=10)
add_gratings = gf.routing.add_fiber_array
ring_sc_gc = gf.compose(add_gratings, ring_sc)
ring_sc_gc5 = ring_sc_gc(radius=5)
ring_sc_gc5.plot()
[13]:
[14]:
ring_sc_gc20 = ring_sc_gc(radius=20)
ring_sc_gc20.plot()
[14]:
This is equivalent and more readable than writing
[15]:
ring_sc_gc5 = add_gratings(ring_sc(radius=5))
ring_sc_gc5.plot()